home *** CD-ROM | disk | FTP | other *** search
/ Pascal Super Library / Pascal Super Library (CW International)(1997).bin / LIBRARY / PAS_0493 / VGALOAD.PAS < prev    next >
Pascal/Delphi Source File  |  1993-04-23  |  10KB  |  309 lines
  1. ─ Fido Pascal Conference ────────────────────────────────────────────── PASCAL ─
  2. Msg  : 582 of 702                                                               
  3. From : Alex Summers                        1:103/714.0          22 Apr 93  02:05 
  4. To   : All                                                                       
  5. Subj : VGA Loaders                                                            
  6. ────────────────────────────────────────────────────────────────────────────────
  7. {      
  8.      I'm assuming that you don't understand the concept of video memory, so  
  9. I'll start off from the basics then.  Video memory is defined (for our own  
  10. purposes) as the memory that the video board scans in determining what signals 
  11. (analog) to send to the monitor.  In graphics mode, the segment of the location
  12.  
  13. of this is determined by what type of video mode you are on - 
  14. VGA/EGA modes = $A000 ($=hex), CGA modes = $B800, and Herc = $B000.  The 
  15. offsets always start off at $0. 
  16.  
  17.      Now, what type of organization are the pixels (since we're in graphics  
  18. mode) stored in?  Because of the simplicity of Mode $13 (320x200x256), most 
  19. VGA intros are written using this.  I'm not about to go ahead and explain to 
  20. you the other VGA modes dealing in the color planes, EGA/VGA registers,etc in 
  21. the higher resolution modes, there are a couple of good books out there that 
  22. can handle those of you interested in that.  Try your local bookstores and look
  23. for Power Graphics Programming by Michael Abrash, which contains his articles  
  24. about higher resolution VGA programming from Programmer's Journal.  HIGHLY  
  25. recommendable.  In any case, in this mode, each pixel on the screen  
  26. corresponds to exactly 1 byte on the video memory.  For example, location 
  27. (0,0) = Mem[$A000:0], (1,0) = Mem[$A000:1], (2,0) = Mem[A000:2], and so on. 
  28. Fairly easy eh?  Because the memory map is linear, the next line would just be 
  29. the next byte AFTER the previous line's last pixel.  For example, location 
  30. (0,319) = Mem[$A000:319], AND THEN location (1,0) = Mem[$A000:320].  And the  
  31. formula for determining the video memory location is 
  32.  
  33.      Video Mem Offset = YPos*320 + XPos 
  34.  
  35.      The actual color of the byte values stored in the video memory is 
  36. flexible and can be changed to any color of the 256,000 palette of the VGA. 
  37. This can be accomplished by altering the VGA Video DAC registers at port 
  38. addresses $3C6 through $3C9.  To read the current settings, set the Table 
  39. Read Index (port $3C7) to the color value you want, and then read the three 
  40. values from the Table Data Register (port $3C9) (one each for Red, Green, and 
  41. Blue).  Once three values have been read from that port, the current read 
  42. index is incremented by one and the next three 6 bit (range of 2, or 0 to 63) 
  43. values read are for the next color value.  Writing the to the Video DAC is 
  44. similar, except the Table Write Index is port $3C8.  Again, after writing 
  45. three successive 6 bit values to the Table Data Registers increments the Write 
  46. Index by one.  By the way, all the reference information about the Video DAC's 
  47. can be obtained from any EGA/VGA reference book.  I recommend getting 
  48. Advanced Programmer's Guide to the EGA/VGA by George Sutty and Steve Blair. 
  49.  
  50.      Waiting for the vertical retrace start signal before updating the video 
  51. memory is the key to smooth animation (with a quick memory update too of 
  52. course).  The idea is to have the screen changes "pop up" before your eyes, and
  53.  
  54. to do this, you need to make your changes just before the the screen trace 
  55. of the video memory occurs.  For this reason, updating the video memory had 
  56. better fast enough, and generally this is the part done in assembly.  The 
  57. important port and bit locations, and a sample implementation are as follows: 
  58.  
  59.        In Pascal: 
  60.  
  61.          Repeat Until (Port[$3DA] And $08) = 0; 
  62.          Repeat Until (Port[$3DA] And $08) <> 0; 
  63.  
  64.        And in Assembly: 
  65.  
  66.                    MOV   DX,3DAh 
  67.          Wait:     IN    AL,DX 
  68.                    TEST  AL,08h 
  69.                    JZ    Wait 
  70.          Retr:     IN    AL,DX 
  71.                    TEST  AL,08h 
  72.                    JNZ   Retr 
  73.  
  74.  
  75.      And finally, how to get the characters on the screen.  I used the old 
  76. character set that's stored in BIOS because it saves time and space (instead 
  77. of capturing a graphical message).  The memory address for this is 
  78. $F000:$FA6E.  Because the character set is 8 bits by 8 bits, each character 
  79. takes up 8 bytes, each byte representing a horizontal slice of the character. 
  80. It's really not that confusing after fiddling around with it. 
  81. } 
  82.  
  83. Program PaletteTricks; 
  84.  
  85.   Uses Crt; 
  86.  
  87.  
  88.   Const CGA_CharSet_Seg = $0F000; 
  89.         CGA_CharSet_Ofs = $0FA6E; 
  90.         CharLength      = 8; 
  91.         NumChars        = 256; 
  92.         VGA_Segment     = $0A000; 
  93.         NumCycles       = 200; 
  94.         Radius          = 80; 
  95.  
  96.         DispStr         : String = 
  97. 'Loader by THG'; 
  98.  
  99.         Colors : Array[1..15*3] Of Byte = 
  100.                  (  7,  7, 63, 
  101.                    15, 15, 63, 
  102.                    23, 23, 63, 
  103.                    31, 31, 63, 
  104.                    39, 39, 63, 
  105.                    47, 47, 63, 
  106.                    55, 55, 63, 
  107.                    63, 63, 63, 
  108.                    55, 55, 63, 
  109.                    47, 47, 63, 
  110.                    39, 39, 63, 
  111.                    31, 31, 63, 
  112.                    23, 23, 63, 
  113.                    15, 15, 63, 
  114.                     7,  7, 63  ); 
  115.  
  116.  
  117. Type  OneChar =Array[1..CharLength] Of Byte; 
  118.  
  119.  
  120. Var   CharSet : Array[1..NumChars] Of OneChar; 
  121.       Locs    : Array[1..NumCycles] Of Integer; 
  122.       BarLocs : Array[1..4] Of Integer; 
  123.  
  124.  
  125.   Procedure GetChars; 
  126.  
  127.     Var NumCounter, 
  128.         ByteCounter, 
  129.         MemCounter   :Integer; 
  130.    
  131.     Begin { GetChars } 
  132.       MemCounter:=0; 
  133.       For NumCounter:=1 To NumChars Do 
  134.         For ByteCounter:=1 To CharLength Do 
  135.           Begin 
  136.            
  137. CharSet[NumCounter][ByteCounter]:=Mem[CGA_CharSet_Seg:CGA_CharSet_Ofs          
  138. Inc(MemCounter); 
  139.           End; 
  140.     End;  { GetChars } 
  141.  
  142.  
  143.   Procedure VideoMode ( Mode : Byte ); 
  144.  
  145.     Begin { VideoMode } 
  146.       Asm 
  147.         Mov  AH,00 
  148.         Mov  AL,Mode 
  149.         Int  10h 
  150.       End; 
  151.     End;  { VideoMode } 
  152.  
  153.  
  154.   Procedure SetColor ( Color, Red, Green, Blue : Byte ); 
  155.  
  156.     Begin { SetColor } 
  157.       Port[$3C8] := Color; 
  158.       Port[$3C9] := Red; 
  159.       Port[$3C9] := Green; 
  160.       Port[$3C9] := Blue; 
  161.     End;  { SetColor } 
  162.  
  163.  
  164.   Procedure DispVert ( Var CurrLine : Integer ); 
  165.  
  166.     Var Letter : OneChar; 
  167.         VertLine, 
  168.         Count  : Integer; 
  169.  
  170.     Begin { DispVert }
  171.  
  172.       Letter := CharSet[Ord(DispStr[(CurrLine Div 8)+1])+1]; 
  173.       VertLine := (CurrLine-1) Mod 8; 
  174.       For Count := 1 To 8 Do 
  175.         If Letter[Count] And ($80 Shr VertLine) = 0 
  176.           Then Mem[VGA_Segment:185*320+(Count-1)*320+319] := 0 
  177.           Else Mem[VGa_Segment:185*320+(Count-1)*320+319] := 181; 
  178.     End;  { DispVert } 
  179.  
  180.  
  181.   Procedure CalcLocs; 
  182.  
  183.     Var Count : Integer; 
  184.  
  185.     Begin { CalcLocs } 
  186.       For Count := 1 To NumCycles Do 
  187.         Locs[Count] := Round(Radius*Sin((2*Pi/NumCycles)*Count))+Radius+1; 
  188.     End;  { CalcLocs } 
  189.  
  190.  
  191.     Procedure DoCycle; 
  192.  
  193.       Label Wait,Retr,BarLoop,PrevIsLast,Continue1,Continue2,Rep1,Rep2; 
  194.  
  195.       Begin { DoCycle } 
  196.         Asm 
  197.  
  198.           MOV   DX,3DAh 
  199. Wait:     IN    AL,DX 
  200.           TEST  AL,08h 
  201.           JZ    Wait 
  202. Retr:     IN    AL,DX 
  203.           TEST  AL,08h 
  204.           JNZ   Retr 
  205.  
  206. { Do Bars... } 
  207.  
  208.            MOV   BX,0 
  209. BarLoop: 
  210.            PUSH  BX 
  211.            MOV   AX,Word Ptr BarLocs[BX] 
  212.            MOV   BX,AX 
  213.            DEC   BX 
  214.            SHL   BX,1 
  215.            MOV   AX,Word Ptr Locs[BX] 
  216.            PUSH  AX 
  217.            CMP   BX,0 
  218.            JE    PrevIsLast 
  219.            DEC   BX 
  220.            DEC   BX 
  221.            MOV   AX,Word Ptr Locs[BX] 
  222.            JMP   Continue1 
  223.  
  224. PrevIsLast: 
  225.            MOV   AX,Word Ptr Locs[(NumCycles-1)*2] 
  226.  
  227. Continue1: 
  228.            MOV   DX,03C8h 
  229.            OUT   DX,AL 
  230.            INC   DX 
  231.            MOV   CX,15*3 
  232.            MOV   AL,0 
  233. Rep1: 
  234.            OUT   DX,AL 
  235.            LOOP  Rep1 
  236.  
  237.            DEC   DX 
  238.            POP   AX 
  239.            OUT   DX,AL 
  240.            INC   DX 
  241.            MOV   CX,15*3 
  242.            XOR   BX,BX 
  243. Rep2: 
  244.            MOV   AL,Byte Ptr Colors[BX] 
  245.            OUT   DX,AL 
  246.            INC   BX 
  247.            LOOP  Rep2 
  248.  
  249.            POP   BX 
  250.            INC   Word Ptr BarLocs[BX] 
  251.            CMP   Word Ptr BarLocs[BX],NumCycles 
  252.            JNG   Continue2 
  253.  
  254.            Mov   Word Ptr BarLocs[BX],1 
  255. Continue2: 
  256.            INC   BX 
  257.            INC   BX 
  258.            CMP   BX,8 
  259.            JNE   BarLoop 
  260.  
  261.         End; 
  262.       End;  { DoCycle } 
  263.  
  264.  
  265.   Var CurrVert, 
  266.       Count     : Integer; 
  267.       Key       : Char; 
  268.       MemPos    : Word; 
  269.  
  270.   Begin { PaletteTricks } 
  271.  
  272.     VideoMode($13); 
  273.     Port[$3C8] := 1; 
  274.     For Count := 1 To 180 Do 
  275.       SetColor(Count,0,0,0); 
  276.     MemPos := 0; 
  277.     For Count := 1 To 180 Do 
  278.       Begin 
  279.         FillChar(Mem[VGA_Segment:MemPos],320,Chr(Count)); 
  280.         MemPos := MemPos + 320; 
  281.       End; 
  282.     SetColor(181,63,63,0); 
  283.     CalcLocs; 
  284.     For Count := 1 To 4 Do 
  285.       BarLocs[Count] := Count*10; 
  286.  
  287.     GetChars; 
  288.     CurrVert := 1; 
  289.     Repeat 
  290.       DoCycle; 
  291.       For Count := 1 To 8 Do 
  292.         Move(Mem[VGA_Segment:185*320+(Count-1)*320+1], 
  293.              Mem[VGA_Segment:185*320+(Count-1)*320],319); 
  294.       DispVert(CurrVert); 
  295.       Inc(CurrVert); 
  296.       If CurrVert > Length(DispStr) * 8 
  297.         Then CurrVert := 1; 
  298.  
  299.     Until Keypressed; 
  300.     Key := ReadKey; 
  301.     VideoMode(3); 
  302.   End.  { PaletteTricks } 
  303.  
  304. ... OFFLINE 1.41 
  305.  
  306. --- Squish v1.01
  307.  * Origin: Starbase Atlantis (1:103/714)
  308.  
  309.